Merge branch 'master' into scratch/correct-warning-pos

diff --cc lisp/emacs-lisp/bindat.el
Simple merge

diff --cc lisp/emacs-lisp/byte-opt.el
Simple merge

diff --cc lisp/emacs-lisp/byte-run.el
Simple merge

diff --cc lisp/emacs-lisp/bytecomp.el
index 47b5d6cecaa5764300163c75a74807725ab1da6c,708e612360607c44c891acb3b9eed85d0c95731c..b3197a97021e46de49ad9e67e087e780e533bb7a
--- 1/lisp/emacs-lisp/bytecomp.el
--- 2/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@@ -1790,13 -1712,11 +1787,13 @@@ It is too wide if it has any lines long
                            (nth 2 form)))))
        (when (and (consp name) (eq (car name) 'quote))
          (setq name (cadr name)))
-       (setq name (if name (format " `%s'" name) ""))
+       (setq name (if name (format " `%s' " name) ""))
        (when (and kind docs (stringp docs)
                   (byte-compile--wide-docstring-p docs col))
 -        (byte-compile-warn "%s%sdocstring wider than %s characters"
 -                           kind name col))))
 +        (byte-compile-warn-x
 +         name
 +         "%s%s docstring wider than %s characters"
 +         kind name col))))
    form)
  
  ;; If we have compiled any calls to functions which are not known to be
@@@ -2778,19 -2675,8 +2774,10 @@@ list that represents a doc string refer
  (put 'make-obsolete 'byte-hunk-handler 'byte-compile-file-form-make-obsolete)
  (defun byte-compile-file-form-make-obsolete (form)
    (prog1 (byte-compile-keep-pending form)
 -    (apply 'make-obsolete (mapcar 'eval (cdr form)))))
 +    (apply 'make-obsolete
 +           (mapcar 'eval
 +                   (macroexp-strip-symbol-positions (cdr form))))))
  
- ;; This handler is not necessary, but it makes the output from dont-compile
- ;; and similar macros cleaner.
- (put 'eval 'byte-hunk-handler 'byte-compile-file-form-eval)
- (defun byte-compile-file-form-eval (form)
-   (if (and (eq (car-safe (nth 1 form)) 'quote)
-            (equal (nth 2 form) lexical-binding))
-       (nth 1 (nth 1 form))
-     (byte-compile-keep-pending form)))
- 
  (defun byte-compile-file-form-defmumble (name macro arglist body rest)
    "Process a `defalias' for NAME.
  If MACRO is non-nil, the definition is known to be a macro.

diff --cc lisp/emacs-lisp/cconv.el
Simple merge

diff --cc lisp/emacs-lisp/cl-generic.el
Simple merge

diff --cc lisp/emacs-lisp/cl-macs.el
Simple merge

diff --cc lisp/emacs-lisp/comp.el
Simple merge

diff --cc lisp/emacs-lisp/easy-mmode.el
Simple merge

diff --cc lisp/emacs-lisp/eieio-core.el
Simple merge

diff --cc lisp/emacs-lisp/eieio.el
Simple merge

diff --cc lisp/emacs-lisp/gv.el
Simple merge

diff --cc lisp/emacs-lisp/macroexp.el
index 11204f7f7fb05ac304f64691812dad0a91b77a63,b44917f7d56b67e4c75f821c310a88b7299e477e..663856a8fb337d346ab94f936942ada230286639
--- 1/lisp/emacs-lisp/macroexp.el
--- 2/lisp/emacs-lisp/macroexp.el
+++ b/lisp/emacs-lisp/macroexp.el
@@@ -208,10 -135,13 +208,13 @@@ Other uses risk returning non-nil valu
  
  (defvar macroexp--warned (make-hash-table :test #'equal :weakness 'key))
  
 -(defun macroexp--warn-wrap (msg form category)
 +(defun macroexp--warn-wrap (arg msg form category)
-   (let ((when-compiled (lambda ()
-                          (when (byte-compile-warning-enabled-p category)
-                            (byte-compile-warn-x arg "%s" msg)))))
+   (let ((when-compiled
+        (lambda ()
+            (when (if (consp category)
+                      (apply #'byte-compile-warning-enabled-p category)
+                    (byte-compile-warning-enabled-p category))
 -             (byte-compile-warn "%s" msg)))))
++             (byte-compile-warn-x arg "%s" msg)))))
      `(progn
         (macroexp--funcall-if-compiled ',when-compiled)
         ,form)))
@@@ -398,19 -339,19 +414,20 @@@ Assumes the caller has bound `macroexpa
        (`(,(or 'function 'quote) . ,_) form)
        (`(,(and fun (or 'let 'let*)) . ,(or `(,bindings . ,body)
                                             pcase--dontcare))
-        (macroexp--cons
-         fun
-         (macroexp--cons
-          (macroexp--all-clauses bindings 1)
-          (if (null body)
-              (macroexp-unprogn
-               (macroexp-warn-and-return
-                fun
-                (format "Empty %s body" fun)
-                nil nil 'compile-only))
-            (macroexp--all-forms body))
-          (cdr form))
-         form))
+        (let ((macroexp--dynvars macroexp--dynvars))
+          (macroexp--cons
+           fun
+           (macroexp--cons
+            (macroexp--all-clauses bindings 1)
+            (if (null body)
+                (macroexp-unprogn
+                 (macroexp-warn-and-return
++                 fun
+                  (format "Empty %s body" fun)
+                  nil nil 'compile-only))
+              (macroexp--all-forms body))
+            (cdr form))
+           form)))
        (`(,(and fun `(lambda . ,_)) . ,args)
         ;; Embedded lambda in function position.
         ;; If the byte-optimizer is loaded, try to unfold this,

diff --cc lisp/emacs-lisp/pcase.el
Simple merge

diff --cc src/.gdbinit
Simple merge

diff --cc src/alloc.c
Simple merge

diff --cc src/comp.c
Simple merge

diff --cc src/data.c
Simple merge

diff --cc src/eval.c
Simple merge

diff --cc src/fns.c
Simple merge

diff --cc src/keyboard.c
Simple merge

diff --cc src/lisp.h
Simple merge

diff --cc src/lread.c
Simple merge

diff --cc src/print.c
Simple merge